home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / dwnodll.cpp < prev    next >
C/C++ Source or Header  |  1996-09-06  |  9KB  |  350 lines
  1. /* Copyright (C) 1996, Russell Lang.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19.  
  20. // dwnodll.cpp
  21.  
  22. // gsdll class  for MS-Windows
  23.  
  24. // Alternate implementation which doesn't use a DLL at all.
  25. // Instead Ghostscript is statically linked in to the EXE
  26. // and this code makes dw*.c think that it really does have
  27. // the GS DLL loaded.
  28.  
  29.  
  30. #define STRICT
  31. #include <windows.h>
  32. #include <string.h>
  33. #include <stdio.h>
  34.  
  35. extern "C" {
  36. #include "gsdll.h"
  37. }
  38.  
  39. #include "dwdll.h"   // gsdll_class
  40.  
  41. static char not_loaded[] = "DLL is not loaded";
  42. static char func_null[]  = "A function pointer to the DLL is NULL";
  43. static char not_init[] = "Not initialized";
  44.  
  45. int
  46. gsdll_class::load(const HINSTANCE in_hinstance, 
  47.     const char *name, const long need_version)
  48. {
  49.     // Don't load if already loaded
  50.     if (hmodule)
  51.     return 0;
  52.     hinstance = in_hinstance;
  53.     initialized = FALSE;
  54.   
  55.     // Act like we have loaded the DLL
  56.     // Use the caller instance so that resources are loaded correctly
  57.     hmodule = hinstance;
  58.  
  59. // Need to cause the same thing to happen in gp_mswin.c
  60.     
  61.  
  62.     // Get pointers to functions
  63.     // Under Win32, nothing special is needed.
  64.     // Under Win16, the functions are _export and hence need a
  65.     // thunk created by MakeProcInstance
  66. #ifdef __WIN32__
  67.     c_revision = gsdll_revision;
  68.     c_init = gsdll_init;
  69.     c_execute_begin = gsdll_execute_begin;
  70.     c_execute_cont = gsdll_execute_cont;
  71.     c_execute_end = gsdll_execute_end;
  72.     c_exit = gsdll_exit;
  73.     c_lock_device = gsdll_lock_device;
  74.     c_copy_dib = gsdll_copy_dib;
  75.     c_copy_palette = gsdll_copy_palette;
  76.     c_draw = gsdll_draw;
  77. #else
  78.     c_revision = (PFN_gsdll_revision) MakeProcInstance(gsdll_revision, hmodule);
  79.     if (c_revision == NULL) {
  80.     sprintf(last_error, "Can't make prolog for gsdll_revision\n");
  81.     unload();
  82.     return 1;
  83.     }
  84.     // check DLL version
  85.     c_revision(NULL, NULL, &version, NULL);
  86.     if (version != need_version) {
  87.     sprintf(last_error, "Wrong version of DLL found.\n  Found version %ld\n  Need version  %ld\n", version, need_version);
  88.     unload();
  89.     return 1;
  90.     }
  91.  
  92.     // continue loading other functions */
  93.     c_init = (PFN_gsdll_init) MakeProcInstance(gsdll_init, hmodule);
  94.     if (c_init == NULL) {
  95.     sprintf(last_error, "Can't make prolog for gsdll_init\n");
  96.     unload();
  97.     return 1;
  98.     }
  99.     c_execute_begin = (PFN_gsdll_execute_begin) MakeProcInstance(gsdll_execute_begin, hmodule);
  100.     if (c_execute_begin == NULL) {
  101.     sprintf(last_error, "Can't make prolog for gsdll_execute_begin\n");
  102.     unload();
  103.     return 1;
  104.     }
  105.     c_execute_cont = (PFN_gsdll_execute_cont) MakeProcInstance(gsdll_execute_cont, hmodule);
  106.     if (c_execute_cont == NULL) {
  107.     sprintf(last_error, "Can't make prolog for gsdll_execute_cont\n");
  108.     unload();
  109.     return 1;
  110.     }
  111.     c_execute_end = (PFN_gsdll_execute_end) MakeProcInstance(gsdll_execute_end, hmodule);
  112.     if (c_execute_end == NULL) {
  113.     sprintf(last_error, "Can't make prolog for gsdll_execute_end\n");
  114.     unload();
  115.     return 1;
  116.     }
  117.     c_exit = (PFN_gsdll_exit) MakeProcInstance(gsdll_exit, hmodule);
  118.     if (c_exit == NULL) {
  119.     sprintf(last_error, "Can't make prolog for gsdll_exit\n");
  120.     unload();
  121.     return 1;
  122.     }
  123.     c_lock_device = (PFN_gsdll_lock_device) MakeProcInstance(gsdll_lock_device, hmodule);
  124.     if (c_lock_device == NULL) {
  125.     sprintf(last_error, "Can't make prolog for gsdll_lock_device\n");
  126.     unload();
  127.     return 1;
  128.     }
  129.     c_copy_dib = (PFN_gsdll_copy_dib) MakeProcInstance(gsdll_copy_dib, hmodule);
  130.     if (c_copy_dib == NULL) {
  131.     sprintf(last_error, "Can't make prolog for gsdll_copy_dib\n");
  132.     unload();
  133.     return 1;
  134.     }
  135.     c_copy_palette = (PFN_gsdll_copy_palette) MakeProcInstance(gsdll_copy_palette, hmodule);
  136.     if (c_copy_palette == NULL) {
  137.     sprintf(last_error, "Can't make prolog for gsdll_copy_palette\n");
  138.     unload();
  139.     return 1;
  140.     }
  141.     c_draw = (PFN_gsdll_draw) MakeProcInstance(gsdll_draw, hmodule);
  142.     if (c_draw == NULL) {
  143.     sprintf(last_error, "Can't make prolog for gsdll_draw\n");
  144.     unload();
  145.     return 1;
  146.     }
  147. #endif
  148.     return 0;
  149. }
  150.  
  151. int
  152. gsdll_class::unload(void)
  153. {
  154.     // exit Ghostscript interpreter
  155.     if (initialized) {
  156.     if (!execute_code)
  157.         c_execute_end();
  158.     c_exit();
  159. #ifndef __WIN32__
  160.     FreeProcInstance((FARPROC)callback);
  161. #endif
  162.         callback = NULL;
  163.     }
  164.  
  165.     // For Win16, must free the thunks.
  166. #ifndef __WIN32__
  167. // is it safe to call these with NULL pointers?
  168.     FreeProcInstance(c_revision);
  169.     FreeProcInstance(c_init);
  170.     FreeProcInstance(c_execute_begin);
  171.     FreeProcInstance(c_execute_cont);
  172.     FreeProcInstance(c_execute_end);
  173.     FreeProcInstance(c_exit);
  174.     FreeProcInstance(c_lock_device);
  175.     FreeProcInstance(c_copy_dib);
  176.     FreeProcInstance(c_copy_palette);
  177.     FreeProcInstance(c_draw);
  178. #endif
  179.  
  180.     // Set functions to NULL to prevent use
  181.     c_revision = NULL;
  182.     c_init = NULL;
  183.     c_execute_begin = NULL;
  184.     c_execute_cont = NULL;
  185.     c_execute_end = NULL;
  186.     c_exit = NULL;
  187.     c_lock_device = NULL;
  188.     c_copy_dib = NULL;
  189.     c_copy_palette = NULL;
  190.     c_draw = NULL;
  191.  
  192.     // need to do more than this
  193.     device = NULL;
  194.  
  195.     // Don't do anything else if already unloaded
  196.     if (hmodule == (HINSTANCE)NULL)
  197.     return 0;
  198.  
  199.     return 0;
  200. }
  201.  
  202. int 
  203. gsdll_class::revision(char FAR * FAR *product, char FAR * FAR *copyright, 
  204.     long FAR *revision, long FAR *revisiondate)
  205. {
  206.     if (!hmodule) {
  207.     strcpy(last_error, not_loaded);
  208.     return 1;
  209.     }
  210.     if (!c_revision)
  211.     return c_revision(product, copyright, revision, revisiondate);
  212.     strcpy(last_error, func_null);
  213.     return 1;
  214. }
  215.  
  216. int 
  217. gsdll_class::init(GSDLL_CALLBACK in_callback, HWND hwnd, int argc, char FAR * FAR *argv)
  218. {
  219. int rc;
  220.     execute_code = 0;
  221.     if (!hmodule) {
  222.     strcpy(last_error, not_loaded);
  223.     return 1;
  224.     }
  225.     if (initialized) {
  226.     strcpy(last_error, "Already initialized");
  227.     return 1;
  228.     }
  229.     if (in_callback == (GSDLL_CALLBACK)NULL) {
  230.     strcpy(last_error, "Callback not provided");
  231.     return 1;
  232.     }
  233.  
  234. #ifdef __WIN32__
  235.     callback = in_callback;
  236. #else
  237.     callback = (GSDLL_CALLBACK)MakeProcInstance((FARPROC)in_callback, hinstance);
  238. #endif
  239.  
  240.     if (c_init && c_execute_begin) {
  241.     rc = c_init(callback, hwnd, argc, argv);
  242.     if (rc) {
  243.         sprintf(last_error, "gsdll_init returns %d\nDLL already in use", rc);
  244.         return rc;
  245.     }
  246.     else {
  247.         if ((rc = c_execute_begin()) != 0)
  248.             sprintf(last_error, "gsdll_execute_begin returns %d", rc);
  249.         else
  250.             initialized = TRUE;
  251.         return rc;
  252.     }
  253.     }
  254.     strcpy(last_error, func_null);
  255.     return 1;
  256. }
  257.  
  258. int
  259. gsdll_class::restart(int argc, char FAR * FAR *argv)
  260. {
  261.     if (!hmodule) {
  262.     strcpy(last_error, not_loaded);
  263.     return 1;
  264.     }
  265.     if (!initialized) {
  266.     strcpy(last_error, not_init);
  267.     return 1;
  268.     }
  269.     if (c_execute_end && c_exit) {
  270.     if (!execute_code)
  271.         c_execute_end();
  272.     c_exit();
  273. #ifndef __WIN32__
  274.     FreeProcInstance((FARPROC)callback);
  275. #endif
  276.     // ignore return codes since they we may be aborting from an error
  277.     initialized = FALSE;
  278.     return init(callback, hwnd, argc, argv);
  279.     }
  280.  
  281.     strcpy(last_error, func_null);
  282.     return 1;
  283. }
  284.  
  285. int 
  286. gsdll_class::get_last_error(char *str, int len)
  287. {
  288.     strncpy(str, last_error,  
  289.     (len < sizeof(last_error) ? len : sizeof(last_error)));
  290.     return 0;
  291. }
  292.  
  293.  
  294. int 
  295. gsdll_class::execute(const char FAR *str, int len)
  296. {
  297.     if (!hmodule) {
  298.     strcpy(last_error, not_loaded);
  299.     return 1;
  300.     }
  301.     if (!initialized) {
  302.     strcpy(last_error, not_init);
  303.     return 1;
  304.     }
  305.     if (c_execute_cont) {
  306.     execute_code = c_execute_cont(str, len);
  307.     return execute_code;
  308.     }
  309.  
  310.     strcpy(last_error, func_null);
  311.     return 1;
  312. }
  313.  
  314. int 
  315. gsdll_class::draw(const char FAR *device, HDC hdc, int dx, int dy, int wx, int wy, int sx, int sy)
  316. {
  317. RECT source, dest;
  318.     source.left = sx;
  319.     source.right = sx+wx;
  320.     source.top = sy;
  321.     source.bottom = sy+wy;
  322.  
  323.     dest.left = dx;
  324.     dest.right = dx+wx;
  325.     dest.top = dy;
  326.     dest.bottom = dy+wy;
  327.     c_draw((unsigned char FAR *)device, hdc, &dest, &source);
  328.     return 0;
  329. }
  330.  
  331. HPALETTE 
  332. gsdll_class::copy_palette(const char FAR *device)
  333. {
  334.     return c_copy_palette((unsigned char FAR *)device);
  335. }
  336.  
  337.  
  338. HGLOBAL
  339. gsdll_class::copy_dib(const char FAR *device)
  340. {
  341.     return c_copy_dib((unsigned char FAR *)device);
  342. }
  343.  
  344.  
  345. int 
  346. gsdll_class::lock_device(const char FAR *device, int lock)
  347. {
  348.     return c_lock_device((unsigned char FAR *)device, lock);
  349. }
  350.